home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / kgdb.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  9.3 KB  |  284 lines
  1. /*
  2.  * This provides the callbacks and functions that KGDB needs to share between
  3.  * the core, I/O and arch-specific portions.
  4.  *
  5.  * Author: Amit Kale <amitkale@linsyssoft.com> and
  6.  *         Tom Rini <trini@kernel.crashing.org>
  7.  *
  8.  * 2001-2004 (c) Amit S. Kale and 2003-2005 (c) MontaVista Software, Inc.
  9.  * This file is licensed under the terms of the GNU General Public License
  10.  * version 2. This program is licensed "as is" without any warranty of any
  11.  * kind, whether express or implied.
  12.  */
  13. #ifndef _KGDB_H_
  14. #define _KGDB_H_
  15.  
  16. #include <linux/serial_8250.h>
  17. #include <linux/linkage.h>
  18. #include <linux/init.h>
  19.  
  20. #include <asm/atomic.h>
  21. #include <asm/kgdb.h>
  22.  
  23. struct pt_regs;
  24.  
  25. /**
  26.  *    kgdb_skipexception - (optional) exit kgdb_handle_exception early
  27.  *    @exception: Exception vector number
  28.  *    @regs: Current &struct pt_regs.
  29.  *
  30.  *    On some architectures it is required to skip a breakpoint
  31.  *    exception when it occurs after a breakpoint has been removed.
  32.  *    This can be implemented in the architecture specific portion of
  33.  *    for kgdb.
  34.  */
  35. extern int kgdb_skipexception(int exception, struct pt_regs *regs);
  36.  
  37. /**
  38.  *    kgdb_post_primary_code - (optional) Save error vector/code numbers.
  39.  *    @regs: Original pt_regs.
  40.  *    @e_vector: Original error vector.
  41.  *    @err_code: Original error code.
  42.  *
  43.  *    This is usually needed on architectures which support SMP and
  44.  *    KGDB.  This function is called after all the secondary cpus have
  45.  *    been put to a know spin state and the primary CPU has control over
  46.  *    KGDB.
  47.  */
  48. extern void kgdb_post_primary_code(struct pt_regs *regs, int e_vector,
  49.                   int err_code);
  50.  
  51. /**
  52.  *    kgdb_disable_hw_debug - (optional) Disable hardware debugging hook
  53.  *    @regs: Current &struct pt_regs.
  54.  *
  55.  *    This function will be called if the particular architecture must
  56.  *    disable hardware debugging while it is processing gdb packets or
  57.  *    handling exception.
  58.  */
  59. extern void kgdb_disable_hw_debug(struct pt_regs *regs);
  60.  
  61. struct tasklet_struct;
  62. struct task_struct;
  63. struct uart_port;
  64.  
  65. /**
  66.  *    kgdb_breakpoint - compiled in breakpoint
  67.  *
  68.  *    This will be impelmented a static inline per architecture.  This
  69.  *    function is called by the kgdb core to execute an architecture
  70.  *    specific trap to cause kgdb to enter the exception processing.
  71.  *
  72.  */
  73. void kgdb_breakpoint(void);
  74.  
  75. extern int kgdb_connected;
  76.  
  77. extern atomic_t            kgdb_setting_breakpoint;
  78. extern atomic_t            kgdb_cpu_doing_single_step;
  79.  
  80. extern struct task_struct    *kgdb_usethread;
  81. extern struct task_struct    *kgdb_contthread;
  82.  
  83. enum kgdb_bptype {
  84.     BP_BREAKPOINT = 0,
  85.     BP_HARDWARE_BREAKPOINT,
  86.     BP_WRITE_WATCHPOINT,
  87.     BP_READ_WATCHPOINT,
  88.     BP_ACCESS_WATCHPOINT
  89. };
  90.  
  91. enum kgdb_bpstate {
  92.     BP_UNDEFINED = 0,
  93.     BP_REMOVED,
  94.     BP_SET,
  95.     BP_ACTIVE
  96. };
  97.  
  98. struct kgdb_bkpt {
  99.     unsigned long        bpt_addr;
  100.     unsigned char        saved_instr[BREAK_INSTR_SIZE];
  101.     enum kgdb_bptype    type;
  102.     enum kgdb_bpstate    state;
  103. };
  104.  
  105. #ifndef KGDB_MAX_BREAKPOINTS
  106. # define KGDB_MAX_BREAKPOINTS    1000
  107. #endif
  108.  
  109. #define KGDB_HW_BREAKPOINT    1
  110.  
  111. /*
  112.  * Functions each KGDB-supporting architecture must provide:
  113.  */
  114.  
  115. /**
  116.  *    kgdb_arch_init - Perform any architecture specific initalization.
  117.  *
  118.  *    This function will handle the initalization of any architecture
  119.  *    specific callbacks.
  120.  */
  121. extern int kgdb_arch_init(void);
  122.  
  123. /**
  124.  *    kgdb_arch_exit - Perform any architecture specific uninitalization.
  125.  *
  126.  *    This function will handle the uninitalization of any architecture
  127.  *    specific callbacks, for dynamic registration and unregistration.
  128.  */
  129. extern void kgdb_arch_exit(void);
  130.  
  131. /**
  132.  *    pt_regs_to_gdb_regs - Convert ptrace regs to GDB regs
  133.  *    @gdb_regs: A pointer to hold the registers in the order GDB wants.
  134.  *    @regs: The &struct pt_regs of the current process.
  135.  *
  136.  *    Convert the pt_regs in @regs into the format for registers that
  137.  *    GDB expects, stored in @gdb_regs.
  138.  */
  139. extern void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs);
  140.  
  141. /**
  142.  *    sleeping_thread_to_gdb_regs - Convert ptrace regs to GDB regs
  143.  *    @gdb_regs: A pointer to hold the registers in the order GDB wants.
  144.  *    @p: The &struct task_struct of the desired process.
  145.  *
  146.  *    Convert the register values of the sleeping process in @p to
  147.  *    the format that GDB expects.
  148.  *    This function is called when kgdb does not have access to the
  149.  *    &struct pt_regs and therefore it should fill the gdb registers
  150.  *    @gdb_regs with what has    been saved in &struct thread_struct
  151.  *    thread field during switch_to.
  152.  */
  153. extern void
  154. sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p);
  155.  
  156. /**
  157.  *    gdb_regs_to_pt_regs - Convert GDB regs to ptrace regs.
  158.  *    @gdb_regs: A pointer to hold the registers we've received from GDB.
  159.  *    @regs: A pointer to a &struct pt_regs to hold these values in.
  160.  *
  161.  *    Convert the GDB regs in @gdb_regs into the pt_regs, and store them
  162.  *    in @regs.
  163.  */
  164. extern void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs);
  165.  
  166. /**
  167.  *    kgdb_arch_handle_exception - Handle architecture specific GDB packets.
  168.  *    @vector: The error vector of the exception that happened.
  169.  *    @signo: The signal number of the exception that happened.
  170.  *    @err_code: The error code of the exception that happened.
  171.  *    @remcom_in_buffer: The buffer of the packet we have read.
  172.  *    @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into.
  173.  *    @regs: The &struct pt_regs of the current process.
  174.  *
  175.  *    This function MUST handle the 'c' and 's' command packets,
  176.  *    as well packets to set / remove a hardware breakpoint, if used.
  177.  *    If there are additional packets which the hardware needs to handle,
  178.  *    they are handled here.  The code should return -1 if it wants to
  179.  *    process more packets, and a %0 or %1 if it wants to exit from the
  180.  *    kgdb callback.
  181.  */
  182. extern int
  183. kgdb_arch_handle_exception(int vector, int signo, int err_code,
  184.                char *remcom_in_buffer,
  185.                char *remcom_out_buffer,
  186.                struct pt_regs *regs);
  187.  
  188. /**
  189.  *    kgdb_roundup_cpus - Get other CPUs into a holding pattern
  190.  *    @flags: Current IRQ state
  191.  *
  192.  *    On SMP systems, we need to get the attention of the other CPUs
  193.  *    and get them be in a known state.  This should do what is needed
  194.  *    to get the other CPUs to call kgdb_wait(). Note that on some arches,
  195.  *    the NMI approach is not used for rounding up all the CPUs. For example,
  196.  *    in case of MIPS, smp_call_function() is used to roundup CPUs. In
  197.  *    this case, we have to make sure that interrupts are enabled before
  198.  *    calling smp_call_function(). The argument to this function is
  199.  *    the flags that will be used when restoring the interrupts. There is
  200.  *    local_irq_save() call before kgdb_roundup_cpus().
  201.  *
  202.  *    On non-SMP systems, this is not called.
  203.  */
  204. extern void kgdb_roundup_cpus(unsigned long flags);
  205.  
  206. /* Optional functions. */
  207. extern int kgdb_validate_break_address(unsigned long addr);
  208. extern int kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr);
  209. extern int kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle);
  210.  
  211. /**
  212.  * struct kgdb_arch - Describe architecture specific values.
  213.  * @gdb_bpt_instr: The instruction to trigger a breakpoint.
  214.  * @flags: Flags for the breakpoint, currently just %KGDB_HW_BREAKPOINT.
  215.  * @set_breakpoint: Allow an architecture to specify how to set a software
  216.  * breakpoint.
  217.  * @remove_breakpoint: Allow an architecture to specify how to remove a
  218.  * software breakpoint.
  219.  * @set_hw_breakpoint: Allow an architecture to specify how to set a hardware
  220.  * breakpoint.
  221.  * @remove_hw_breakpoint: Allow an architecture to specify how to remove a
  222.  * hardware breakpoint.
  223.  * @remove_all_hw_break: Allow an architecture to specify how to remove all
  224.  * hardware breakpoints.
  225.  * @correct_hw_break: Allow an architecture to specify how to correct the
  226.  * hardware debug registers.
  227.  */
  228. struct kgdb_arch {
  229.     unsigned char        gdb_bpt_instr[BREAK_INSTR_SIZE];
  230.     unsigned long        flags;
  231.  
  232.     int    (*set_breakpoint)(unsigned long, char *);
  233.     int    (*remove_breakpoint)(unsigned long, char *);
  234.     int    (*set_hw_breakpoint)(unsigned long, int, enum kgdb_bptype);
  235.     int    (*remove_hw_breakpoint)(unsigned long, int, enum kgdb_bptype);
  236.     void    (*remove_all_hw_break)(void);
  237.     void    (*correct_hw_break)(void);
  238. };
  239.  
  240. /**
  241.  * struct kgdb_io - Describe the interface for an I/O driver to talk with KGDB.
  242.  * @name: Name of the I/O driver.
  243.  * @read_char: Pointer to a function that will return one char.
  244.  * @write_char: Pointer to a function that will write one char.
  245.  * @flush: Pointer to a function that will flush any pending writes.
  246.  * @init: Pointer to a function that will initialize the device.
  247.  * @pre_exception: Pointer to a function that will do any prep work for
  248.  * the I/O driver.
  249.  * @post_exception: Pointer to a function that will do any cleanup work
  250.  * for the I/O driver.
  251.  */
  252. struct kgdb_io {
  253.     const char        *name;
  254.     int            (*read_char) (void);
  255.     void            (*write_char) (u8);
  256.     void            (*flush) (void);
  257.     int            (*init) (void);
  258.     void            (*pre_exception) (void);
  259.     void            (*post_exception) (void);
  260. };
  261.  
  262. extern struct kgdb_arch        arch_kgdb_ops;
  263.  
  264. extern unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs);
  265.  
  266. extern int kgdb_register_io_module(struct kgdb_io *local_kgdb_io_ops);
  267. extern void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops);
  268.  
  269. extern int kgdb_hex2long(char **ptr, unsigned long *long_val);
  270. extern int kgdb_mem2hex(char *mem, char *buf, int count);
  271. extern int kgdb_hex2mem(char *buf, char *mem, int count);
  272.  
  273. extern int kgdb_isremovedbreak(unsigned long addr);
  274.  
  275. extern int
  276. kgdb_handle_exception(int ex_vector, int signo, int err_code,
  277.               struct pt_regs *regs);
  278. extern int kgdb_nmicallback(int cpu, void *regs);
  279.  
  280. extern int            kgdb_single_step;
  281. extern atomic_t            kgdb_active;
  282.  
  283. #endif /* _KGDB_H_ */
  284.